<!DOCTYPE html>



  


<html class="theme-next pisces use-motion" lang="zh-Hans">
<head><meta name="generator" content="Hexo 3.8.0">
  <meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="theme-color" content="#222">









<meta http-equiv="Cache-Control" content="no-transform">
<meta http-equiv="Cache-Control" content="no-siteapp">
















  
  
  <link href="/lib/fancybox/source/jquery.fancybox.css?v=2.1.5" rel="stylesheet" type="text/css">







<link href="/lib/font-awesome/css/font-awesome.min.css?v=4.6.2" rel="stylesheet" type="text/css">

<link href="/css/main.css?v=5.1.4" rel="stylesheet" type="text/css">


  <link rel="apple-touch-icon" sizes="180x180" href="/images/apple-touch-icon-next.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="32x32" href="/images/favicon-32x32-next.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="16x16" href="/images/favicon-16x16-next.png?v=5.1.4">


  <link rel="mask-icon" href="/images/logo.svg?v=5.1.4" color="#222">





  <meta name="keywords" content="Hexo, NexT">










<meta name="description" content="Java面向对象的三个特征与含义封装 含义：属性的封装和方法的封装。把属性定义为私有的，get()，set()方法。好处：信息隐藏和模块化，提高安全性。封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性。  继承 含义：子类可以继承父类的成员变量和成员方法。好处：继承可以提高代码的复用性。  继承的特性 单一继承； 子类只能继承父类的非私有成员变量和方法。 成员变量的隐藏和方法的覆盖。  多">
<meta property="og:type" content="article">
<meta property="og:title" content="Java基础之理论知识">
<meta property="og:url" content="https://mingmingv.gitee.io/2018/10/27/Java基础之理论知识/index.html">
<meta property="og:site_name" content="四 季">
<meta property="og:description" content="Java面向对象的三个特征与含义封装 含义：属性的封装和方法的封装。把属性定义为私有的，get()，set()方法。好处：信息隐藏和模块化，提高安全性。封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性。  继承 含义：子类可以继承父类的成员变量和成员方法。好处：继承可以提高代码的复用性。  继承的特性 单一继承； 子类只能继承父类的非私有成员变量和方法。 成员变量的隐藏和方法的覆盖。  多">
<meta property="og:locale" content="zh-Hans">
<meta property="og:updated_time" content="2018-11-01T12:14:44.771Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="Java基础之理论知识">
<meta name="twitter:description" content="Java面向对象的三个特征与含义封装 含义：属性的封装和方法的封装。把属性定义为私有的，get()，set()方法。好处：信息隐藏和模块化，提高安全性。封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性。  继承 含义：子类可以继承父类的成员变量和成员方法。好处：继承可以提高代码的复用性。  继承的特性 单一继承； 子类只能继承父类的非私有成员变量和方法。 成员变量的隐藏和方法的覆盖。  多">



<script type="text/javascript" id="hexo.configurations">
  var NexT = window.NexT || {};
  var CONFIG = {
    root: '/',
    scheme: 'Pisces',
    version: '5.1.4',
    sidebar: {"position":"left","display":"post","offset":12,"b2t":false,"scrollpercent":false,"onmobile":false},
    fancybox: true,
    tabs: true,
    motion: {"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"slideDownIn","post_body":"slideDownIn","coll_header":"slideLeftIn","sidebar":"slideUpIn"}},
    duoshuo: {
      userId: '0',
      author: '博主'
    },
    algolia: {
      applicationID: '',
      apiKey: '',
      indexName: '',
      hits: {"per_page":10},
      labels: {"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}
    }
  };
</script>



  <link rel="canonical" href="https://mingmingv.gitee.io/2018/10/27/Java基础之理论知识/">





  <title>Java基础之理论知识 | 四 季</title>
  








</head>

<body itemscope="" itemtype="http://schema.org/WebPage" lang="zh-Hans">

  
  
    
  

  <div class="container sidebar-position-left page-post-detail">
    <div class="headband"></div>

    <header id="header" class="header" itemscope="" itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-wrapper">
  <div class="site-meta ">
    

    <div class="custom-logo-site-title">
      <a href="/" class="brand" rel="start">
        <span class="logo-line-before"><i></i></span>
        <span class="site-title">四 季</span>
        <span class="logo-line-after"><i></i></span>
      </a>
    </div>
      
        <p class="site-subtitle"></p>
      
  </div>

  <div class="site-nav-toggle">
    <button>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
    </button>
  </div>
</div>

<nav class="site-nav">
  

  
    <ul id="menu" class="menu">
      
        
        <li class="menu-item menu-item-home">
          <a href="/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-home"></i> <br>
            
            首页
          </a>
        </li>
      
        
        <li class="menu-item menu-item-archives">
          <a href="/archives/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-archive"></i> <br>
            
            归档
          </a>
        </li>
      
        
        <li class="menu-item menu-item-tags">
          <a href="/tags/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-tags"></i> <br>
            
            标签
          </a>
        </li>
      

      
    </ul>
  

  
</nav>



 </div>
    </header>

    <main id="main" class="main">
      <div class="main-inner">
        <div class="content-wrap">
          <div id="content" class="content">
            

  <div id="posts" class="posts-expand">
    

  

  
  
  

  <article class="post post-type-normal" itemscope="" itemtype="http://schema.org/Article">
  
  
  
  <div class="post-block">
    <link itemprop="mainEntityOfPage" href="https://mingmingv.gitee.io/2018/10/27/Java基础之理论知识/">

    <span hidden itemprop="author" itemscope="" itemtype="http://schema.org/Person">
      <meta itemprop="name" content="四 季">
      <meta itemprop="description" content="">
      <meta itemprop="image" content="/images/avatar.gif">
    </span>

    <span hidden itemprop="publisher" itemscope="" itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="四 季">
    </span>

    
      <header class="post-header">

        
        
          <h1 class="post-title" itemprop="name headline">Java基础之理论知识</h1>
        

        <div class="post-meta">
          <span class="post-time">
            
              <span class="post-meta-item-icon">
                <i class="fa fa-calendar-o"></i>
              </span>
              
                <span class="post-meta-item-text">发表于</span>
              
              <time title="创建于" itemprop="dateCreated datePublished" datetime="2018-10-27T14:55:39+08:00">
                2018-10-27
              </time>
            

            

            
          </span>

          

          
            
          

          
          

          

          

          

        </div>
      </header>
    

    
    
    
    <div class="post-body" itemprop="articleBody">

      
      

      
        <h1 id="Java面向对象的三个特征与含义"><a href="#Java面向对象的三个特征与含义" class="headerlink" title="Java面向对象的三个特征与含义"></a>Java面向对象的三个特征与含义</h1><h2 id="封装"><a href="#封装" class="headerlink" title="封装"></a>封装</h2><blockquote>
<p>含义：属性的封装和方法的封装。把属性定义为私有的，get()，set()方法。<br>好处：信息隐藏和模块化，提高安全性。封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性。</p>
</blockquote>
<h2 id="继承"><a href="#继承" class="headerlink" title="继承"></a>继承</h2><blockquote>
<p>含义：子类可以继承父类的成员变量和成员方法。<br>好处：继承可以提高代码的复用性。</p>
</blockquote>
<h3 id="继承的特性"><a href="#继承的特性" class="headerlink" title="继承的特性"></a>继承的特性</h3><ul>
<li>单一继承；</li>
<li>子类只能继承父类的非私有成员变量和方法。</li>
<li>成员变量的隐藏和方法的覆盖。</li>
</ul>
<h2 id="多态"><a href="#多态" class="headerlink" title="多态"></a>多态</h2><blockquote>
<p>含义：当统一操作作用在不同对象时，会产生不同的结果。<br>实现原理：继承、重写、向上转型。</p>
</blockquote>
<h3 id="Java动态的实现原理"><a href="#Java动态的实现原理" class="headerlink" title="Java动态的实现原理"></a>Java动态的实现原理</h3><pre><code>有2种方式实现多态，一种是编译时多态，另外一种是运行时动态；编译时多态是通过方法的重载来实现的，运行时多态是通过方法的重写来实现的。
</code></pre><ul>
<li>方法的重载，指的是同一个类中有多个同名的方法，但这些方法有着不同的参数，<strong>在编译时就可以确定到底调用哪个方法。</strong></li>
<li>方法的重写，子类重写父类中的方法。父类的引用变量不仅可以指向父类的实例对象，还可以指向子类的实例对象，当父类的引用指向子类的对象时，只有在运行是才能确定调用哪个方法。</li>
<li><strong>特别注意：</strong>只有类中的方法才有多态的概念，类中成员变量没有多态的概念。</li>
</ul>
<h2 id="Override（覆盖、重写）和-Overload（重载）的区别"><a href="#Override（覆盖、重写）和-Overload（重载）的区别" class="headerlink" title="Override（覆盖、重写）和 Overload（重载）的区别"></a>Override（覆盖、重写）和 Overload（重载）的区别</h2><ul>
<li>重载和覆盖是java多态性的不同表现方式。</li>
<li>重载是在一个类中的多态性的一种表现，是指在一个类中定义了刀割同名的方法，但是他们有不同的参数个属于或有不同的参数类型。</li>
</ul>
<h3 id="使用重载时要注意一下几点："><a href="#使用重载时要注意一下几点：" class="headerlink" title="使用重载时要注意一下几点："></a>使用重载时要注意一下几点：</h3><ol>
<li>重载只能通过不同的方法区分，例如：<strong>不同的参数类型，不同的参数个数，不同的参数顺序</strong>。</li>
<li><strong>不能</strong>通过<strong>访问权限、返回类型、抛出的异常</strong>进行重载。</li>
</ol>
<h4 id="覆盖是指子类函数覆盖父类中的函数"><a href="#覆盖是指子类函数覆盖父类中的函数" class="headerlink" title="覆盖是指子类函数覆盖父类中的函数"></a>覆盖是指子类函数覆盖父类中的函数</h4><h4 id="在覆盖时注意一下几点-重点！"><a href="#在覆盖时注意一下几点-重点！" class="headerlink" title="在覆盖时注意一下几点(重点！)"></a>在覆盖时注意一下几点(重点！)</h4><ol>
<li>覆盖的方法的函数名和参数必须要和被覆盖的方法的<strong>函数名和参数</strong>完全匹配，才能达到覆盖的效果；</li>
<li>覆盖的方法的返回值必须和被覆盖的方法的<strong>返回值类型一致；</strong></li>
<li>覆盖的方法所抛出的异常必须和被覆盖方法的<strong>所抛出的异常一致，或者是其子类；</strong></li>
<li><strong>被覆盖的方法不能为 private，</strong>否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。</li>
<li>子 类 函 数 的 访 问 修 饰 权 限 要 大 于 等 于 父 类 的<strong>（public&gt;protected&gt;default&gt;private）。（重要！！！</strong>）</li>
</ol>
<ul>
<li><strong>特别注意：</strong> Java中，子类无法覆盖父类的static方法会private方法。</li>
</ul>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">class Parent &#123;</span><br><span class="line">public static void <span class="function"><span class="title">p</span></span>() &#123;</span><br><span class="line">System.out.println(<span class="string">"parent...."</span>);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">public class Test19 extends Parent &#123;</span><br><span class="line">public static void <span class="function"><span class="title">p</span></span>() &#123;</span><br><span class="line">System.out.println(<span class="string">"child..."</span>);</span><br><span class="line">&#125;</span><br><span class="line">public static void main(String[] args) &#123;</span><br><span class="line">Parent parent = new Test19();</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>输出：</p>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">parent....</span><br></pre></td></tr></table></figure>
<blockquote>
<p>原因：Java 中，子类无法覆盖父类的 static 方法。</p>
</blockquote>
<h2 id="静态内部类和非静态内部类的区别"><a href="#静态内部类和非静态内部类的区别" class="headerlink" title="静态内部类和非静态内部类的区别"></a>静态内部类和非静态内部类的区别</h2><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br></pre></td><td class="code"><pre><span class="line">/* 下面程序演示如何在 java 中创建静态内部类和非静态内部类 */</span><br><span class="line">class OuterClass &#123;</span><br><span class="line">private static String msg = <span class="string">"GeeksForGeeks"</span>;</span><br><span class="line">// 静态内部类</span><br><span class="line">public static class NestedStaticClass &#123;</span><br><span class="line">// 静态内部类只能访问外部类的静态成员和静态方法</span><br><span class="line">public void <span class="function"><span class="title">printMessage</span></span>() &#123;</span><br><span class="line">// 试着将 msg 改成非静态的，这将导致编译错误</span><br><span class="line">System.out.println(<span class="string">"Message from nested static class:</span></span><br><span class="line"><span class="string">"</span> + msg);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">// 非静态内部类</span><br><span class="line">public class InnerClass &#123;</span><br><span class="line">// 不管是静态方法还是非静态方法都可以在非静态内部类中访问</span><br><span class="line">public void <span class="function"><span class="title">display</span></span>() &#123;</span><br><span class="line">System.out.println(<span class="string">"Message from non-static nested</span></span><br><span class="line"><span class="string">class: "</span> + msg);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">public class Main &#123;</span><br><span class="line">// 怎么创建静态内部类和非静态内部类的实例</span><br><span class="line">public static void main(String args[]) &#123;</span><br><span class="line">// 创建静态内部类的实例（注意前面还是要加外部类的名字的！！！）</span><br><span class="line">OuterClass.NestedStaticClass printer = new</span><br><span class="line">OuterClass.NestedStaticClass();</span><br><span class="line">// 调用静态内部类的非静态方法</span><br><span class="line">printer.printMessage();</span><br><span class="line">// 为了创建非静态内部类，我们需要外部类的实例</span><br><span class="line">OuterClass outer = new OuterClass();</span><br><span class="line">OuterClass.InnerClass inner = outer.new InnerClass();</span><br><span class="line">// 调用非静态内部类的非静态方法</span><br><span class="line">inner.display();</span><br><span class="line">// 我们也可以结合以上步骤，一步创建的内部类实例</span><br><span class="line">OuterClass.InnerClass innerObject = new OuterClass().new</span><br><span class="line">InnerClass();</span><br><span class="line">// 同样我们现在可以调用内部类方法</span><br><span class="line">innerObject.display();</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<h3 id="静态内部类和非静态内部类主要的不同："><a href="#静态内部类和非静态内部类主要的不同：" class="headerlink" title="静态内部类和非静态内部类主要的不同："></a>静态内部类和非静态内部类主要的不同：</h3><ol>
<li>静态内部类不依赖于外部类实例而被实例化，而非静态内部类需要在,外部类实例化后才可以被实例化。</li>
<li>静态内部类不需要持有外部类的引用。但非静态内部类需要持有对外部类的引用。</li>
<li>静态内部类不能访问外部类的非静态成员和非静态方法。它只能访问</li>
</ol>
<p>外部类的静态成员和静态方法。非静态内部类能够访问外部类的静态和非静态成员和方法。</p>
<h4 id="扩展：内部类都有哪些？"><a href="#扩展：内部类都有哪些？" class="headerlink" title="扩展：内部类都有哪些？"></a>扩展：内部类都有哪些？</h4><blockquote>
<p>有四种：<strong>静态内部类，非静态内部类，局部内部类，匿名内部类。</strong></p>
</blockquote>
<ol>
<li>静态内部类和非静态内部类的讲解见上面的部分。</li>
<li>局部内部类：在外部类的方法中定义的类。其作用的范围是所在的方法内。它不能被 public,private,protected 来修饰。它只能访问方法中定义为 final类型的局部变量。</li>
</ol>
<ul>
<li>局部内部类：</li>
</ul>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">类型的局部变量。</span><br><span class="line">class outerClass&#123;</span><br><span class="line">public void <span class="function"><span class="title">f</span></span>()&#123;</span><br><span class="line">    class innerClass&#123;//局部内部类</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<ul>
<li>匿名内部类:</li>
</ul>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line">interface Person &#123;</span><br><span class="line">public abstract void eat();</span><br><span class="line">&#125;</span><br><span class="line">public class Test4 &#123;</span><br><span class="line">public static void main(String[] args) &#123;</span><br><span class="line">Person p = new <span class="function"><span class="title">Person</span></span>() &#123;</span><br><span class="line">public void <span class="function"><span class="title">eat</span></span>() &#123;</span><br><span class="line">System.out.println(<span class="string">"eat something"</span>);</span><br><span class="line">&#125;</span><br><span class="line">&#125;;</span><br><span class="line">p.eat();</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<ul>
<li>是一种没有类名的内部类。</li>
</ul>
<h4 id="需要注意的是："><a href="#需要注意的是：" class="headerlink" title="需要注意的是："></a>需要注意的是：</h4><p>4.1 匿名内部类一定是在 new 的后面，这个匿名内部类必须继承一个父类<br>或者实现一个接口。<br>4.2 匿名内部类不能有构造函数。<br>4.3 只能创建匿名内部类的一个实例。<br>4.4 在 Java 8 之前，如果匿名内部类需要访问外部类的局部变量，则必须<br>使用 final 来修饰外部类的局部变量。<strong>在现在的 Java 8 已经去取消了这个限制。</strong></p>
<h2 id="static-的使用方式。"><a href="#static-的使用方式。" class="headerlink" title="static 的使用方式。"></a>static 的使用方式。</h2><blockquote>
<p>static 有 <strong>4</strong> 种使用方式：<strong>修饰类（静态内部类），修饰成员变量（静态变量），修饰成员方法（静态成员方法），静态代码块。</strong></p>
</blockquote>
<ul>
<li>修饰类（静态内部类）</li>
</ul>
<blockquote>
<p>参考上面的介绍。</p>
</blockquote>
<ul>
<li>修饰成员变量（静态变量）</li>
</ul>
<blockquote>
<p>静态变量属于类，只要静态变量所在的类被加载，这个静态变量就会被分配空间，在内存中只有一份，所有对象共享这个静态变量。使用有二种方式，一个是类名.静态变量，还有一种是对象.静态变量。特别注意：不能在方法体中定义静态变量（无论该方法是静态的或是非静态的）。VS 实例变量属于类，只有对象创建后，实例变量才会分配空间。</p>
</blockquote>
<ul>
<li>修饰成员方法（静态成员方法）</li>
</ul>
<blockquote>
<p>静态成员方法属于类，不需要创建对象就可以使用。而非静态方法属于对象，只有在对象创建出来以后才可以被使用。静态方法里面只能访问所属类的静态成员变量和静态成员方法。</p>
</blockquote>
<ul>
<li>静态代码块</li>
</ul>
<blockquote>
<p>静态代码块经常被用来初始化静态变量，在类加载的初始化阶段会执行为静态变量赋值的语句和静态代码块的内容，静态代码块只会被执行一次。</p>
</blockquote>
<h2 id="反射的作用与原理。如何提高反射效率？"><a href="#反射的作用与原理。如何提高反射效率？" class="headerlink" title="反射的作用与原理。如何提高反射效率？"></a>反射的作用与原理。如何提高反射效率？</h2><ol>
<li>定义：反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。在 java 中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。</li>
<li>反射机制主要提供了以下功能：在运行时判定任意一个对象所属的类；在运行时创建对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。</li>
<li>哪里用到反射机制？jdbc 中有一行代码：Class.forName(‘com.mysql.jdbc.Driver.class’);//加载 MySql 的驱动类。这就是反射，现在很多框架都用到反射机制，hibernate，struts 都是用反射机制实现的。</li>
<li>反射的实现方式在 Java 中实现反射最重要的一步，也是第一步就是获取 Class 对象，得到Class 对象后可以通过该对象调用相应的方法来获取该类中的属性、方法以及调用该类中的方法。</li>
</ol>
<h3 id="有-4-种方法可以得到-Class-对象："><a href="#有-4-种方法可以得到-Class-对象：" class="headerlink" title="有 4 种方法可以得到 Class 对象："></a>有 4 种方法可以得到 Class 对象：</h3><ol>
<li>Class.forName(“类的路径”);</li>
<li>类名.class。</li>
<li>对象名.getClass()。</li>
<li>如果是基本类型的包装类，则可以通过调用包装类的 Type 属性来获得该包装类的 Class 对象。例如：Class&lt;?&gt; clazz = Integer.TYPE;</li>
</ol>
<h3 id="4-实现-Java-反射的类"><a href="#4-实现-Java-反射的类" class="headerlink" title="4.实现 Java 反射的类"></a>4.实现 Java 反射的类</h3><ol>
<li>Class：它表示正在运行的 Java 应用程序中的类和接口。</li>
<li>Field：提供有关类或接口的属性信息，以及对它的动态访问权限。</li>
<li>Constructor：提供关于类的单个构造方法的信息以及对它的访问权限</li>
<li>Method：提供关于类或接口中某个方法信息。</li>
<li><strong>注意：Class类是Java反射中最重要的一个功能类，所有获取对象的信息(包括：方法/属性/构造方法/访问权限)都需要它来实现。</strong></li>
<li><strong>反射机制的优缺点？</strong></li>
</ol>
<blockquote>
<p>优点：<br>（1）能够运行时动态获取类的实例，大大提高程序的灵活性。<br>（2）与 Java 动态编译相结合，可以实现无比强大的功能。<br>缺点：<br>（1）使用反射的性能较低。 java 反射是要解析字节码，将内存中的对象进<br>行解析。<br>解决方案：</p>
</blockquote>
<ol>
<li>由于 JDK 的安全检查耗时较多，所以通过 setAccessible(true)的方式关闭安全检查来（取消对访问控制修饰符的检查）提升反射速度。</li>
<li>需要多次动态创建一个类的实例的时候，有缓存的写法会比没有缓存要快很多:</li>
<li>ReflectASM 工具类 ，通过字节码生成的方式加快反射速度。 （2）使用反射相对来说不安全，破坏了类的封装性，可以通过反射获取这个类的私有方法和属性。</li>
</ol>
<h2 id="Java-和-C-C-的区别-JAVA-的优点。"><a href="#Java-和-C-C-的区别-JAVA-的优点。" class="headerlink" title="Java 和 C++/C 的区别,JAVA 的优点。"></a>Java 和 C++/C 的区别,JAVA 的优点。</h2><h3 id="JAVA-和-C-C-的区别："><a href="#JAVA-和-C-C-的区别：" class="headerlink" title="JAVA 和 C/C++的区别："></a>JAVA 和 C/C++的区别：</h3><ol>
<li>运行过程的不同。JAVA 源程序经过编译器编译成字节码文件，然后由 JVM解释执行。而 C++/C 经过编译、链接后生成可执行的二进制代码。因此 C/C++的执行速度比 JAVA 快。</li>
<li>跨平台性。JAVA 可以跨平台，而 C++/C 不可以跨平台。</li>
<li>JAVA 没有指针，C++/C 有指针。</li>
<li>JAVA 不支持多重继承，但是可以同时实现多个接口来达到类似的目的。C++支持多重继承。</li>
<li>JAVA 不需要对内存进行管理，有垃圾回收机制。C/C++需要对内存进行显示的管理。</li>
<li>JAVA 不支持运算符重载。C/C++支持运算符重载。</li>
<li>JAVA 中每个数据类型在不同的平台上所占字节数固定的，而 C/C++则不然。</li>
</ol>
<h3 id="JAVA-的优点："><a href="#JAVA-的优点：" class="headerlink" title="JAVA 的优点："></a>JAVA 的优点：</h3><ol>
<li>跨平台。JAVA 语言可以“一次编译，到处运行”。跨平台的含义：无论是在 windows 平台还是在 Linux 平台对 Java 程序进行编译，编译后的程序都可以在其他平台上运行。编译器会把 JAVA 代码编译成字节码文件，然后在 JVM 上解释执行，由于字节码与平台无关，因此，JAVA 可以很好地跨平台执行。</li>
<li>垃圾回收机制。</li>
<li>去掉了 C++中难以理解的东西，比如指针和运算符重载。</li>
<li>具有较好的安全性。比如 JAVA 有数组边界检测，但是 C/C++里面没有。</li>
</ol>
<h3 id="同一个-java-文件中是否可以有多个-main-方法？"><a href="#同一个-java-文件中是否可以有多个-main-方法？" class="headerlink" title="同一个.java 文件中是否可以有多个 main()方法？"></a>同一个.java 文件中是否可以有多个 main()方法？</h3><blockquote>
<p>每个类中都可以定义 main()方法，但只有用 public 修饰的类且与文件名相同的类中的 main()方法才可以作为整个程序的入口方法。</p>
</blockquote>
<p>例子：创建了一个名为 Test17.java 的文件。</p>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line">class T &#123;</span><br><span class="line">public static void main(String[] args) &#123;</span><br><span class="line">System.out.println(<span class="string">"T main"</span>);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">public class Test17 &#123;</span><br><span class="line">    public static void main(String[] args) &#123;</span><br><span class="line">System.out.println(<span class="string">"Test main"</span>);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">Test main</span><br></pre></td></tr></table></figure>
<h3 id="System-out-println-方法使用时需要注意的问题"><a href="#System-out-println-方法使用时需要注意的问题" class="headerlink" title="System.out.println()方法使用时需要注意的问题"></a>System.out.println()方法使用时需要注意的问题</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">public class Test18 &#123;</span><br><span class="line">public static void main(String[] args) &#123;</span><br><span class="line">System.out.println(1 + 2 + <span class="string">""</span>);</span><br><span class="line">System.out.println(<span class="string">""</span> + 1 + 2);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>输出：</p>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">3</span><br><span class="line">12</span><br></pre></td></tr></table></figure>
<h3 id="final-finally-finalize-的区别"><a href="#final-finally-finalize-的区别" class="headerlink" title="final finally finalize 的区别"></a>final finally finalize 的区别</h3><p>final 可以用来修饰类，变量和方法。</p>
<ul>
<li>当一个类被 final 修饰的时候，表示该类不能被继承。类中方法默认被final 修饰。</li>
<li>当 final 修饰基本数据类型的变量时，表示该值在被初始化后不能更改；</li>
<li>当 final 修饰引用类型的变量时，表示该引用在初始化之后不能再指向其他的对象。</li>
<li>注意：final 修饰的变量必须被初始化。可以在定义的时候初始化，也可以在构造函数中进行初始化。</li>
<li>当 final 修饰方法时，表示这个方法不能被子类重写。</li>
</ul>
<h4 id="使用-final-方法的原因有-2-个："><a href="#使用-final-方法的原因有-2-个：" class="headerlink" title="使用 final 方法的原因有 2 个："></a>使用 final 方法的原因有 2 个：</h4><p>第一、把方法锁定，防止任何继承类修改它的实现。<br>第二、高效。当要使用一个被声明为 final 的方法时，直接将方法主体插<br>入到调用处，而不进行方法调用，可以提高程序的执行效率（ps.如果过多的话，<br>这样会造成代码膨胀）。</p>
<h4 id="扩展：String-类为什么要设计成-final-类型的？"><a href="#扩展：String-类为什么要设计成-final-类型的？" class="headerlink" title="扩展：String 类为什么要设计成 final 类型的？"></a>扩展：String 类为什么要设计成 final 类型的？</h4><p>java 中不仅 String 是 final 的。 Long, Double, Integer 之类的全都是final 的。</p>
<ol>
<li>Requirement of String Pool<blockquote>
<p>If a string is not immutable, changing the string with one reference willlead to the wrong value for the other references.</p>
</blockquote>
</li>
<li>Caching Hashcode 因为字符串是不可变的，所以在它创建的时候 hashcode 就被缓存了，不需要重新计算。</li>
<li>线程安全<blockquote>
<p>Because immutable objects can not be changed, they can be shared among multiple threads freely. This eliminates the requirements of doing synchronization（不用同步了）。</p>
</blockquote>
</li>
<li>为了防止扩展类无意间破坏原来方法的实现。</li>
</ol>
<h4 id="finally-的用法："><a href="#finally-的用法：" class="headerlink" title="finally 的用法："></a>finally 的用法：</h4><blockquote>
<p>finally 是异常处理的一部分，只能用在 try-catch 语句中，表示这段代码一般情况下，一定会执行。经常用在需要释放资源的情况下。</p>
</blockquote>
<h4 id="finalize-的用法："><a href="#finalize-的用法：" class="headerlink" title="finalize 的用法："></a>finalize 的用法：</h4><blockquote>
<p>它是 Object 类的一个方法，在垃圾回收器执行时会调用被回收对象的finalize()方法。</p>
</blockquote>
<h3 id="JDK1-7-和-1-8-的区别"><a href="#JDK1-7-和-1-8-的区别" class="headerlink" title="JDK1.7 和 1.8 的区别"></a>JDK1.7 和 1.8 的区别</h3><h4 id="接口的默认方法。"><a href="#接口的默认方法。" class="headerlink" title="接口的默认方法。"></a>接口的默认方法。</h4><p>Java 8 允许我们给接口添加一个非抽象的方法实现，只需要使用 default<br>关键字即可，这个特征又叫做扩展方法，Default 方法带来的好处是，往接口新<br>增一个 Default 方法，在接口添加新功能特性，而不破坏现有的实现架构。示<br>例如下：</p>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line">interface Formula &#123;</span><br><span class="line">double calculate(int a);</span><br><span class="line">default double sqrt(int a) &#123;</span><br><span class="line"><span class="built_in">return</span> Math.sqrt(a);</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
<p>Formula 接口在拥有 calculate 方法之外同时还定义了 sqrt 方法，实<br>现了 Formula 接口的子类只需要实现一个 calculate 方法，默认方法 sqrt 将<br>在子类上可以直接使用。</p>
<p>Formula 接口在拥有 calculate 方法之外同时还定义了 sqrt 方法，实<br>现了 Formula 接口的子类只需要实现一个 calculate 方法，默认方法 sqrt 将<br>在子类上可以直接使用。</p>
<figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line">Formula formula = new <span class="function"><span class="title">Formula</span></span>() &#123;</span><br><span class="line">public double calculate(int a) &#123;</span><br><span class="line"><span class="built_in">return</span> sqrt(a * 100);</span><br><span class="line">&#125;</span><br><span class="line">&#125;;</span><br><span class="line">formula.calculate(100); // 100.0</span><br><span class="line">formula.sqrt(16); // 4.0</span><br><span class="line">35.List&lt;String&gt;能否转为 List&lt;Object&gt;?能否 List&lt;Object&gt; list= new</span><br><span class="line">ArrayList&lt;String&gt;()？List&lt; String &gt; list= new ArrayList&lt; Object &gt;()？原</span><br><span class="line">因？</span><br></pre></td></tr></table></figure>
<blockquote>
<p>都不可以，会出现编译错误。List9可以存储任何类型的对象，包括 String,Integer 等，而 ArrayList<string>只能用来存储字符串。</string></p>
</blockquote>
<h3 id="泛型的好处？"><a href="#泛型的好处？" class="headerlink" title="泛型的好处？"></a>泛型的好处？</h3><blockquote>
<p>在编译的时候检查类型安全，确保只能把正确类型的对象放入集合中；消除强制类型转换。</p>
</blockquote>
<h3 id="StringBuilder-和-StringBuffer-底层是怎么实现的"><a href="#StringBuilder-和-StringBuffer-底层是怎么实现的" class="headerlink" title="StringBuilder 和 StringBuffer 底层是怎么实现的"></a>StringBuilder 和 StringBuffer 底层是怎么实现的</h3><blockquote>
<p>每个 StringBuffer 对象都有一定的缓冲区容量（可变长的字符数组，类似于ArrayList 的底层实现），默认初始容量为 16 个字符。当字符串大小没有超过容量时，不会分配新的容量；当字符串大小超过容量时，会自动扩容（扩容后的容量大约是之前的 2 倍）。StringBuilder 和 StringBuffer，字符串都是存放在char[]中的。</p>
</blockquote>
<h3 id="String-类中常用的方法"><a href="#String-类中常用的方法" class="headerlink" title="String 类中常用的方法"></a>String 类中常用的方法</h3><ol>
<li>charAt(int index) ：返回指定索引处的 char 值。</li>
<li>intern() ：返回字符串对象的规范化表示形式。</li>
<li>isEmpty() ：当且仅当 length() 为 0 时返回 true。</li>
<li>length() ：返回此字符串的长度。</li>
<li>substring(int beginIndex) ：返回一个新的字符串，它是此字符串的一个子字符串。substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串的一个子字符串。</li>
<li>toLowerCase() ：将此 String 中的所有字符都转换为小写。toUpperCase()：将此 String 中的所有字符都转换为大写。</li>
<li>trim()：去除字符串首尾空格。</li>
<li>valueOf(Object obj) ： 返回 Object 参数的字符串表示形式。</li>
<li>equals(Object anObject) ：将此字符串与指定的对象比较。</li>
</ol>
<h3 id="HashMap-的加载因子的作用"><a href="#HashMap-的加载因子的作用" class="headerlink" title="HashMap 的加载因子的作用"></a>HashMap 的加载因子的作用</h3><blockquote>
<p>加载因子是表示 Hash 表中元素的填满程度。若加载因子越大，填满的元素越多，好处是，空间利用率高了，但冲突的机会加大了，增加查询数据的时间开销。反之，加载因子越小，填满的元素越少，好处是，冲突的机会减小了，会提高数据查询的性能，但空间浪费多了。特别地，JDK1.8 中对 HashMap 进行了增强，如果一个桶上的节点数量过多，链表+数组的结构就会转换为红黑树。</p>
</blockquote>
<h3 id="HashMap-中的-key-可以是任意对象吗？（Set-中元素的内容可以改变吗？）"><a href="#HashMap-中的-key-可以是任意对象吗？（Set-中元素的内容可以改变吗？）" class="headerlink" title="HashMap 中的 key 可以是任意对象吗？（Set 中元素的内容可以改变吗？）"></a>HashMap 中的 key 可以是任意对象吗？（Set 中元素的内容可以改变吗？）</h3><blockquote>
<p>可变对象和不可变对象都可以。可变对象是指创建后自身状态能改变的对象。换句话说，可变对象是该对象在创建后它的哈希值（由类的 hashCode（）方法可以得出哈希值）可能被改变。<br>如果可变对象在 HashMap 中被用作 key，当对象中的属性改变时，则对象HashCode 也可能进行相应的改变，这将导致下次无法查找到已存在 Map 中的数据；或者当想删除被改变对象的时候，由于找不到该对象，无法删除，会造成内存泄漏。 所以当 hashCode( )重写的时候，最好不能依赖该类的易变属性，这样就可以保证成员变量改变的时候，该对象的哈希值不变。</p>
</blockquote>
<h3 id="如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为-key？"><a href="#如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为-key？" class="headerlink" title="如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为 key？"></a>如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为 key？</h3><blockquote>
<p>需要重写 equals( )方法和 hashCode（）方法，必须保证对象的属性改变时，其 hashCode()返回值不能改变。</p>
</blockquote>
<h3 id="java-是如何实现跨平台的"><a href="#java-是如何实现跨平台的" class="headerlink" title="java 是如何实现跨平台的"></a>java 是如何实现跨平台的</h3><blockquote>
<p>java 跨平台的实质是虚拟机的跨平台。JVM 也是一个软件，不同的平台有不同的版本。我们编写的 Java 源码，编译后会生成一种 .class 文件，称为字节码文件。Java 虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的 JVM，就可以运行字节码文件，运行我们编写的 Java 程序。</p>
</blockquote>
<h3 id="什么是泛型，为什么要使用以及类型擦除"><a href="#什么是泛型，为什么要使用以及类型擦除" class="headerlink" title="什么是泛型，为什么要使用以及类型擦除"></a>什么是泛型，为什么要使用以及类型擦除</h3><ul>
<li>泛型的本质就是“参数化类型”，也就是说所操作的数据类型被指定为一个参数。创建集合时就指定集合元素的数据类型，该集合只能保存其指定类型的元素，避免使用强制类型转换。</li>
<li>Java 编译器生成的字节码是不包含泛型信息的，泛型类型信息将在编译处理时被擦除，这个过程即类型擦除。类型擦除可以简单的理解为将泛型 java 代码转换为普通 java 代码，只不过编译器更直接点，将泛型 java 代码直接转换成普通java 字节码。</li>
</ul>
<h4 id="类型擦除的主要过程如下："><a href="#类型擦除的主要过程如下：" class="headerlink" title="类型擦除的主要过程如下："></a>类型擦除的主要过程如下：</h4><ol>
<li>将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。</li>
<li>移除所有的类型参数。</li>
</ol>
<h3 id="Java-中的-NIO，BIO-分别是什么。NIO-主要用来解决什么问题"><a href="#Java-中的-NIO，BIO-分别是什么。NIO-主要用来解决什么问题" class="headerlink" title="Java 中的 NIO，BIO 分别是什么。NIO 主要用来解决什么问题"></a>Java 中的 NIO，BIO 分别是什么。NIO 主要用来解决什么问题</h3><blockquote>
<p>NIO 的主要作用就是用来解决速度差异的。</p>
</blockquote>
<ul>
<li>Java 中 NIO 和 IO 之间的区别</li>
</ul>
<h4 id="面向流与面向缓冲"><a href="#面向流与面向缓冲" class="headerlink" title="面向流与面向缓冲"></a>面向流与面向缓冲</h4><ul>
<li>Java NIO 和 IO 之间第一个最大的区别是，IO 是面向流的，NIO 是面向缓冲区的。</li>
<li>Java IO 面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。在 Java NIO中把数据读取到一个缓冲区中，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。</li>
</ul>
<h4 id="阻塞与非阻塞-IO"><a href="#阻塞与非阻塞-IO" class="headerlink" title="阻塞与非阻塞 IO"></a>阻塞与非阻塞 IO</h4><ul>
<li>Java IO 的各种流是阻塞的。这意味着，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。</li>
<li>Java NIO 的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。</li>
<li>一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞 IO 的空闲时间用于在其它通道上执行 IO 操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。</li>
</ul>
<h4 id="选择器（Selector）"><a href="#选择器（Selector）" class="headerlink" title="选择器（Selector）"></a>选择器（Selector）</h4><blockquote>
<p>Java NIO 的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。为了将 Channel 和Selector 配合使用，必须将 channel 注册到 selector 上，通过SelectableChannel.register()方法来实现。这种选择机制，使得一个单独的线程很容易来管理多个通道。只要 Channel 向 Selector 注册了某种特定的事件，Selector 就会监听这些事件是否会发生，一旦发生某个事件，便会通知对应的Channel。使用选择器，借助单一线程，就可对数量庞大的活动 I/O 通道实施监控和维护。</p>
</blockquote>
<h3 id="NIO-的原理"><a href="#NIO-的原理" class="headerlink" title="NIO 的原理"></a>NIO 的原理</h3><h4 id="在-NIO-中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。"><a href="#在-NIO-中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。" class="headerlink" title="在 NIO 中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。"></a>在 NIO 中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。</h4><p>一．缓冲区（Buffer）</p>
<ul>
<li>缓冲区实际上是一个容器对象，其实就是一个数组，在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，它也是写入到缓冲区中的；任何时候访问 NIO 中的数据，都是将它放到缓冲区中。在 NIO 中，所有的缓冲区类型都继承于抽象类 Buffer，最常用的就是 ByteBuffer。</li>
<li>而在面向流 I/O 系统中，所有数据都是直接写入或者直接将数据读取到Stream 对象中。</li>
</ul>
<h3 id="面向对象的-6-个基本原则（设计模式的-6-个基本原则）"><a href="#面向对象的-6-个基本原则（设计模式的-6-个基本原则）" class="headerlink" title="面向对象的 6 个基本原则（设计模式的 6 个基本原则）"></a>面向对象的 6 个基本原则（设计模式的 6 个基本原则）</h3><ul>
<li>s( Single-Resposibility Principle ): 单一职责原则。</li>
<li>o( Open-Closed principle ): 开放封闭原则。</li>
<li>l( Liskov-Substituion Principle ): 里氏替换原则。</li>
<li>i( Interface-Segregation Principle ): 接口隔离原则。</li>
<li>d( Dependecy-Inversion Principle ): 依赖倒置原则。</li>
<li>合成/聚合复用。</li>
</ul>
<blockquote>
<p>1.<strong>单一职责：</strong>是指一个类的功能要单一，一个类只负责一个职责。一个类只做它该做的事情(高内聚)。在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则。<br>2.<strong>开放封闭：</strong>软件实体应当对扩展开放，对修改关闭。对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。对修改封闭，意味着类一旦设计完成，就可以独立其工作，而不要对类尽任何修改。在开发阶段，我们都知道，如果对一个功能进行扩展，如果只是一味地对方法进行修改，可能会造成一些问题，诸如可能会引入新的 bug，或者增加代码的复杂度，对代码结构造成破坏、冗余，还需要重新进行全面的测试。那么该怎么解决这些问题？很简单，这就需要系统能够支持扩展，只有扩展性良好的系统，才能在不进行修改已有实现代码的基础上，引进新的功能。<br>3.<strong>里氏替换：</strong>任何使用基类的地方，都能够使用子类替换，而且在替换子类后，系统能够正常工作。子类一定是增加父类的能力而不是减少父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。 一个软件实体如果使用的是一个基类，那么当把这个基类替换成继承该基类的子类，程序的行为不会发生任何变化。软件实体察觉不出基类对象和子类对象的区别。<br>4.<strong>接口隔离：</strong> 即应该将接口粒度最小化，将功能划分到每一个不能再分的子角色，为每一个子角色创建接口，通过这样，才不会让接口的实现类实现一些不必要的功能。 建立单一的接口，不要建立臃肿的庞大的接口，也就是说接口的方法尽量少。接口要小而专，绝不能大而全。臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。<br>5.<strong>依赖倒置：</strong>即我们的类要依赖于抽象，而不是依赖于具体，也就是我们经常听到的“要面向接口编程”。（该原则说得具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时，尽可能使用抽象类型而不用具体类型，因为抽象类型可以被它的任何一个子类型所替代） 。 依赖倒置原则的本质就是通过抽象（抽象类或接口）使各个类或模块的实现彼此独立，不相互影响，实现模块间的松耦合。减少类间的耦合性。<br>6.<strong>合成/聚合复用：</strong>优先使用聚合或合成关系复用代码。</p>
</blockquote>
<h3 id="JDK-源码中用到的设计模式"><a href="#JDK-源码中用到的设计模式" class="headerlink" title="JDK 源码中用到的设计模式"></a>JDK 源码中用到的设计模式</h3><ul>
<li>单例模式： java.lang.Runtime</li>
</ul>
<blockquote>
<p>Runtime 类封装了 Java 运行时的环境。每一个 java 程序实际上都是启动了一个 JVM 进程，那么每个 JVM 进程都是对应这一个 Runtime 实例，此实例是由 JVM 为其实例化的。每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。由于 Java 是单进程的，所以，在一个 JVM中，Runtime 的实例应该只有一个。所以应该使用单例来实现。一般不能实化一个 Runtime 对象，应用程序也不能创建自己的 Runtime 类实例，但可以通过 getRuntime 方法获取当前 Runtime 运行时对象的引用。</p>
</blockquote>
<ul>
<li>享元模式：String 常量池和 Integer 等包装类的缓存策略：Integer.valueOf(int i)等。</li>
<li>原型模式：Object.clone；Cloneable。</li>
<li>装饰器模式：IO 流中。</li>
<li>迭代器模式：Iterator 。</li>
</ul>
<h3 id="执行-Student-s-new-Student-在内存中做了哪些事情"><a href="#执行-Student-s-new-Student-在内存中做了哪些事情" class="headerlink" title="执行 Student s = new Student();在内存中做了哪些事情"></a>执行 Student s = new Student();在内存中做了哪些事情</h3><ol>
<li>类加载的过程。</li>
<li>对象初始化的顺序（对象实例化的过程）。 见 P28</li>
<li>在栈内存为 s 开辟空间，把对象地址赋值给 s 变量 。</li>
</ol>
<h3 id="你知道的开源软件有哪些？"><a href="#你知道的开源软件有哪些？" class="headerlink" title="你知道的开源软件有哪些？"></a>你知道的开源软件有哪些？</h3><ol>
<li>JDK</li>
<li>Eclipse</li>
<li>Tomcat</li>
<li>MySQL</li>
</ol>
<h3 id="String-型变量如何转成-int-型变量，反过来呢？"><a href="#String-型变量如何转成-int-型变量，反过来呢？" class="headerlink" title="String 型变量如何转成 int 型变量，反过来呢？"></a>String 型变量如何转成 int 型变量，反过来呢？</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">String num =“1000″;</span><br><span class="line">int id=Integer.valueOf(num);</span><br><span class="line">Int a=1000;</span><br><span class="line">String string=String.valueOf(a);</span><br></pre></td></tr></table></figure>
<h3 id="怎么判断数组是-null-还是为空"><a href="#怎么判断数组是-null-还是为空" class="headerlink" title="怎么判断数组是 null 还是为空"></a>怎么判断数组是 null 还是为空</h3><blockquote>
<p>输出 array.length 的值，如果是 0,说明数组为空。如果是 null 的话，会抛出空指针异常。</p>
</blockquote>
<h3 id="怎样让一个线程放弃锁"><a href="#怎样让一个线程放弃锁" class="headerlink" title="怎样让一个线程放弃锁"></a>怎样让一个线程放弃锁</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">Object.wait();</span><br><span class="line">condition.await();</span><br></pre></td></tr></table></figure>
<blockquote>
<p>内容转载自：内推军_JAVA基础</p>
</blockquote>

      
    </div>
    
    
    

    

    

    

    <footer class="post-footer">
      

      
      
      

      
        <div class="post-nav">
          <div class="post-nav-next post-nav-item">
            
              <a href="/2018/10/24/BTA-常问的-Java基础40道常见面试题及详细答案-上集/" rel="next" title="BTA 常问的 Java基础40道常见面试题及详细答案(上集)">
                <i class="fa fa-chevron-left"></i> BTA 常问的 Java基础40道常见面试题及详细答案(上集)
              </a>
            
          </div>

          <span class="post-nav-divider"></span>

          <div class="post-nav-prev post-nav-item">
            
              <a href="/2018/11/01/JAVA-中的集合类/" rel="prev" title="JAVA 中的集合类">
                JAVA 中的集合类 <i class="fa fa-chevron-right"></i>
              </a>
            
          </div>
        </div>
      

      
      
    </footer>
  </div>
  
  
  
  </article>



    <div class="post-spread">
      
    </div>
  </div>


          </div>
          


          

  



        </div>
        
          
  
  <div class="sidebar-toggle">
    <div class="sidebar-toggle-line-wrap">
      <span class="sidebar-toggle-line sidebar-toggle-line-first"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-middle"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-last"></span>
    </div>
  </div>

  <aside id="sidebar" class="sidebar">
    
    <div class="sidebar-inner">

      

      
        <ul class="sidebar-nav motion-element">
          <li class="sidebar-nav-toc sidebar-nav-active" data-target="post-toc-wrap">
            文章目录
          </li>
          <li class="sidebar-nav-overview" data-target="site-overview-wrap">
            站点概览
          </li>
        </ul>
      

      <section class="site-overview-wrap sidebar-panel">
        <div class="site-overview">
          <div class="site-author motion-element" itemprop="author" itemscope="" itemtype="http://schema.org/Person">
            
              <img class="site-author-image" itemprop="image" src="/images/avatar.gif" alt="四 季">
            
              <p class="site-author-name" itemprop="name">四 季</p>
              <p class="site-description motion-element" itemprop="description">我的学习笔记站</p>
          </div>

          <nav class="site-state motion-element">

            
              <div class="site-state-item site-state-posts">
              
                <a href="/archives/">
              
                  <span class="site-state-item-count">15</span>
                  <span class="site-state-item-name">日志</span>
                </a>
              </div>
            

            

            

          </nav>

          

          

          
          

          
          

          

        </div>
      </section>

      
      <!--noindex-->
        <section class="post-toc-wrap motion-element sidebar-panel sidebar-panel-active">
          <div class="post-toc">

            
              
            

            
              <div class="post-toc-content"><ol class="nav"><li class="nav-item nav-level-1"><a class="nav-link" href="#Java面向对象的三个特征与含义"><span class="nav-number">1.</span> <span class="nav-text">Java面向对象的三个特征与含义</span></a><ol class="nav-child"><li class="nav-item nav-level-2"><a class="nav-link" href="#封装"><span class="nav-number">1.1.</span> <span class="nav-text">封装</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#继承"><span class="nav-number">1.2.</span> <span class="nav-text">继承</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#继承的特性"><span class="nav-number">1.2.1.</span> <span class="nav-text">继承的特性</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#多态"><span class="nav-number">1.3.</span> <span class="nav-text">多态</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#Java动态的实现原理"><span class="nav-number">1.3.1.</span> <span class="nav-text">Java动态的实现原理</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#Override（覆盖、重写）和-Overload（重载）的区别"><span class="nav-number">1.4.</span> <span class="nav-text">Override（覆盖、重写）和 Overload（重载）的区别</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#使用重载时要注意一下几点："><span class="nav-number">1.4.1.</span> <span class="nav-text">使用重载时要注意一下几点：</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#覆盖是指子类函数覆盖父类中的函数"><span class="nav-number">1.4.1.1.</span> <span class="nav-text">覆盖是指子类函数覆盖父类中的函数</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#在覆盖时注意一下几点-重点！"><span class="nav-number">1.4.1.2.</span> <span class="nav-text">在覆盖时注意一下几点(重点！)</span></a></li></ol></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#静态内部类和非静态内部类的区别"><span class="nav-number">1.5.</span> <span class="nav-text">静态内部类和非静态内部类的区别</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#静态内部类和非静态内部类主要的不同："><span class="nav-number">1.5.1.</span> <span class="nav-text">静态内部类和非静态内部类主要的不同：</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#扩展：内部类都有哪些？"><span class="nav-number">1.5.1.1.</span> <span class="nav-text">扩展：内部类都有哪些？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#需要注意的是："><span class="nav-number">1.5.1.2.</span> <span class="nav-text">需要注意的是：</span></a></li></ol></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#static-的使用方式。"><span class="nav-number">1.6.</span> <span class="nav-text">static 的使用方式。</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#反射的作用与原理。如何提高反射效率？"><span class="nav-number">1.7.</span> <span class="nav-text">反射的作用与原理。如何提高反射效率？</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#有-4-种方法可以得到-Class-对象："><span class="nav-number">1.7.1.</span> <span class="nav-text">有 4 种方法可以得到 Class 对象：</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#4-实现-Java-反射的类"><span class="nav-number">1.7.2.</span> <span class="nav-text">4.实现 Java 反射的类</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#Java-和-C-C-的区别-JAVA-的优点。"><span class="nav-number">1.8.</span> <span class="nav-text">Java 和 C++/C 的区别,JAVA 的优点。</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#JAVA-和-C-C-的区别："><span class="nav-number">1.8.1.</span> <span class="nav-text">JAVA 和 C/C++的区别：</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#JAVA-的优点："><span class="nav-number">1.8.2.</span> <span class="nav-text">JAVA 的优点：</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#同一个-java-文件中是否可以有多个-main-方法？"><span class="nav-number">1.8.3.</span> <span class="nav-text">同一个.java 文件中是否可以有多个 main()方法？</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#System-out-println-方法使用时需要注意的问题"><span class="nav-number">1.8.4.</span> <span class="nav-text">System.out.println()方法使用时需要注意的问题</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#final-finally-finalize-的区别"><span class="nav-number">1.8.5.</span> <span class="nav-text">final finally finalize 的区别</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#使用-final-方法的原因有-2-个："><span class="nav-number">1.8.5.1.</span> <span class="nav-text">使用 final 方法的原因有 2 个：</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#扩展：String-类为什么要设计成-final-类型的？"><span class="nav-number">1.8.5.2.</span> <span class="nav-text">扩展：String 类为什么要设计成 final 类型的？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#finally-的用法："><span class="nav-number">1.8.5.3.</span> <span class="nav-text">finally 的用法：</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#finalize-的用法："><span class="nav-number">1.8.5.4.</span> <span class="nav-text">finalize 的用法：</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#JDK1-7-和-1-8-的区别"><span class="nav-number">1.8.6.</span> <span class="nav-text">JDK1.7 和 1.8 的区别</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#接口的默认方法。"><span class="nav-number">1.8.6.1.</span> <span class="nav-text">接口的默认方法。</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#泛型的好处？"><span class="nav-number">1.8.7.</span> <span class="nav-text">泛型的好处？</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#StringBuilder-和-StringBuffer-底层是怎么实现的"><span class="nav-number">1.8.8.</span> <span class="nav-text">StringBuilder 和 StringBuffer 底层是怎么实现的</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#String-类中常用的方法"><span class="nav-number">1.8.9.</span> <span class="nav-text">String 类中常用的方法</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#HashMap-的加载因子的作用"><span class="nav-number">1.8.10.</span> <span class="nav-text">HashMap 的加载因子的作用</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#HashMap-中的-key-可以是任意对象吗？（Set-中元素的内容可以改变吗？）"><span class="nav-number">1.8.11.</span> <span class="nav-text">HashMap 中的 key 可以是任意对象吗？（Set 中元素的内容可以改变吗？）</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为-key？"><span class="nav-number">1.8.12.</span> <span class="nav-text">如果你定义一个类，包括学号，姓名，分数，如何把这个对象作为 key？</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#java-是如何实现跨平台的"><span class="nav-number">1.8.13.</span> <span class="nav-text">java 是如何实现跨平台的</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#什么是泛型，为什么要使用以及类型擦除"><span class="nav-number">1.8.14.</span> <span class="nav-text">什么是泛型，为什么要使用以及类型擦除</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#类型擦除的主要过程如下："><span class="nav-number">1.8.14.1.</span> <span class="nav-text">类型擦除的主要过程如下：</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-中的-NIO，BIO-分别是什么。NIO-主要用来解决什么问题"><span class="nav-number">1.8.15.</span> <span class="nav-text">Java 中的 NIO，BIO 分别是什么。NIO 主要用来解决什么问题</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#面向流与面向缓冲"><span class="nav-number">1.8.15.1.</span> <span class="nav-text">面向流与面向缓冲</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#阻塞与非阻塞-IO"><span class="nav-number">1.8.15.2.</span> <span class="nav-text">阻塞与非阻塞 IO</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#选择器（Selector）"><span class="nav-number">1.8.15.3.</span> <span class="nav-text">选择器（Selector）</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#NIO-的原理"><span class="nav-number">1.8.16.</span> <span class="nav-text">NIO 的原理</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#在-NIO-中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。"><span class="nav-number">1.8.16.1.</span> <span class="nav-text">在 NIO 中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#面向对象的-6-个基本原则（设计模式的-6-个基本原则）"><span class="nav-number">1.8.17.</span> <span class="nav-text">面向对象的 6 个基本原则（设计模式的 6 个基本原则）</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#JDK-源码中用到的设计模式"><span class="nav-number">1.8.18.</span> <span class="nav-text">JDK 源码中用到的设计模式</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#执行-Student-s-new-Student-在内存中做了哪些事情"><span class="nav-number">1.8.19.</span> <span class="nav-text">执行 Student s = new Student();在内存中做了哪些事情</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#你知道的开源软件有哪些？"><span class="nav-number">1.8.20.</span> <span class="nav-text">你知道的开源软件有哪些？</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#String-型变量如何转成-int-型变量，反过来呢？"><span class="nav-number">1.8.21.</span> <span class="nav-text">String 型变量如何转成 int 型变量，反过来呢？</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#怎么判断数组是-null-还是为空"><span class="nav-number">1.8.22.</span> <span class="nav-text">怎么判断数组是 null 还是为空</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#怎样让一个线程放弃锁"><span class="nav-number">1.8.23.</span> <span class="nav-text">怎样让一个线程放弃锁</span></a></li></ol></li></ol></li></ol></div>
            

          </div>
        </section>
      <!--/noindex-->
      

      

    </div>
  </aside>


        
      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="footer-inner">
        <div class="copyright">&copy; <span itemprop="copyrightYear">2019</span>
  <span class="with-love">
    <i class="fa fa-user"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">四 季</span>

  
</div>


  <div class="powered-by">由 <a class="theme-link" target="_blank" href="https://hexo.io">Hexo</a> 强力驱动</div>



  <span class="post-meta-divider">|</span>



  <div class="theme-info">主题 &mdash; <a class="theme-link" target="_blank" href="https://github.com/iissnan/hexo-theme-next">NexT.Pisces</a> v5.1.4</div>




        







        
      </div>
    </footer>

    
      <div class="back-to-top">
        <i class="fa fa-arrow-up"></i>
        
      </div>
    

    

  </div>

  

<script type="text/javascript">
  if (Object.prototype.toString.call(window.Promise) !== '[object Function]') {
    window.Promise = null;
  }
</script>









  












  
  
    <script type="text/javascript" src="/lib/jquery/index.js?v=2.1.3"></script>
  

  
  
    <script type="text/javascript" src="/lib/fastclick/lib/fastclick.min.js?v=1.0.6"></script>
  

  
  
    <script type="text/javascript" src="/lib/jquery_lazyload/jquery.lazyload.js?v=1.9.7"></script>
  

  
  
    <script type="text/javascript" src="/lib/velocity/velocity.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/lib/velocity/velocity.ui.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/lib/fancybox/source/jquery.fancybox.pack.js?v=2.1.5"></script>
  


  


  <script type="text/javascript" src="/js/src/utils.js?v=5.1.4"></script>

  <script type="text/javascript" src="/js/src/motion.js?v=5.1.4"></script>



  
  


  <script type="text/javascript" src="/js/src/affix.js?v=5.1.4"></script>

  <script type="text/javascript" src="/js/src/schemes/pisces.js?v=5.1.4"></script>



  
  <script type="text/javascript" src="/js/src/scrollspy.js?v=5.1.4"></script>
<script type="text/javascript" src="/js/src/post-details.js?v=5.1.4"></script>



  


  <script type="text/javascript" src="/js/src/bootstrap.js?v=5.1.4"></script>



  


  




	





  





  












  





  

  

  

  
  

  

  

  

</body>
</html>
